Function pointers

Dear all,

I try to make a function pointer, here is some sample code:
 

struct Toto {}
 
void titi(Toto toto, int b){
    void fptr(Toto toto, int b);
}
 
void tutu(Toto toto, int b){
        titi(toto,b)
}

This generates the following warnings at execution:

-W- DXL: <addins/user/temp.dxl:11> Le paramètre de fonction a nommé le paramètre (119348960)
Inclus à partir de :
    <Line:1> 
-W- DXL: <addins/user/temp.dxl:11> Le paramètre de fonction a nommé le paramètre (83520656)
Inclus à partir de :
        <Line:1> 
-I- DXL: Terminé. Erreurs signalées : 0. Avertissements signalés : 2.

I would like to know whether those warnings are errors or not, and if not whether it is possible to have some pragma to deactivate locally the warning generation.

Re: Function pointers
SystemAdmin - Thu Apr 12 14:51:26 EDT 2012

I'm a little rusty on my French, but some subset of the below should get you going:
 

// Function Fun
 
/*
  Function Fun
*/
 
 
int* PtrOps_intStarAddressOf(_m &v) {
    int *val = &(addr_ (int (addr_ (v))));
    return (val);
}
 
int PtrOps_addressOfVar(_m& anyVar) {
    int temp = (int addr_ PtrOps_intStarAddressOf(anyVar));
    return temp;
}
 
int PtrOps_internalIntContentOfAddress(int& refToInt) {
    int content = refToInt;
    return content;
}
 
int PtrOps_intContentOfAddress(int address) {
    return (PtrOps_internalIntContentOfAddress(addr_ address));
}
 
 
int PtrOps_addressOfVoidFunctionWithNoParameterHelper(int dummyParameterOne, void function()) {
    int addressOfParameterOne;
    int contentOfParameterOne;
 
    int addressOfParameterTwo;
    int contentOfParameterTwo;
 
    addressOfParameterOne = PtrOps_addressOfVar(dummyParameterOne);
    contentOfParameterOne = PtrOps_intContentOfAddress(addressOfParameterOne);
 
    //--------------------------------------------------------------------------
    // DOORS blows up if you get the address of "void function(void)" function
    // directly.  Alternate approach:
    // 1) Pass in a dummy int parameter prior to the function parameter.
    // 2) Figure out the address of the dummy parameter.
    // 3) We know the temperamental function parameter content is 4 bytes ahead
    //    of the dummy address.
    // 4) Look four bytes ahead and extract an int that lies there.
    // 5) Done
    //--------------------------------------------------------------------------
 
    addressOfParameterTwo = addressOfParameterOne + 4;
    contentOfParameterTwo = PtrOps_intContentOfAddress(addressOfParameterTwo);
 
    return contentOfParameterTwo;
}
 
int PtrOps_addressOfVoidFunctionWithNoParameter(void function()) {
    int dummyParameterOne = 1111;
    return PtrOps_addressOfVoidFunctionWithNoParameterHelper(dummyParameterOne, function);
}
 
int PtrOps_addressOfVoidFunctionWithOneNonRefParameter(void function(_m)) {
    return (int (addr_ function));
}
 
void callNoParameterVoidFunction(void function()) {
    function();
}
 
void callOneParameterVoidFunction(void function(_m)) {
    function("one");
}
 
void oneParameter(string msg) {
    print ">>> Hello from void function with " msg " parameter! <<<\n";
}
 
void noParameter() {
    print ">>> Hello from void function with no parameter! <<<\n";
}
 
void addressOfFunctionDemo() {
    print("I'm calling a one parameter void function directly\n");
    oneParameter("one");
    print("I'm calling a no parameter void function directly\n");
    noParameter();
 
    print("\n");
 
    print("I'm calling a one parameter void function by passing function by typed-function signature\n");
    callOneParameterVoidFunction( oneParameter );
    print("I'm calling a no parameter void function by passing function by typed-function signature\n");
    callNoParameterVoidFunction( noParameter );
 
    print("\n");
 
    int addressOfVoidFunctionWithOneNonRefParameter = PtrOps_addressOfVoidFunctionWithOneNonRefParameter( oneParameter );
    int addressOfVoidFunctionWithNoParameter = PtrOps_addressOfVoidFunctionWithNoParameter( noParameter );
 
    print("The address of a one parameter void function is (in decimal) " (addressOfVoidFunctionWithOneNonRefParameter) "\n");
    print("The address of a no parameter void function is (in decimal) " (addressOfVoidFunctionWithNoParameter) "\n");
 
    print("\n");
 
    print("I'm calling a one parameter void function by hacking-in the address\n");
    callOneParameterVoidFunction( addr_ addressOfVoidFunctionWithOneNonRefParameter );
 
    print("I'm calling a no parameter void function by hacking-in the address\n");
    callNoParameterVoidFunction( addr_ addressOfVoidFunctionWithNoParameter );
}
 
addressOfFunctionDemo();

Re: Function pointers
adevicq - Fri Apr 13 03:24:33 EDT 2012

Bonjour,

Here is an example of function pointers:
 

void fCalled(int i, string s) {
...
}
 
// declare your function as a parameter without naming the functions' parameters
void fMain(int a, void f(int, string)) {
string b="toto"
...
f(a, b)
}
 
// call the function with the name of the called function...
fMain(12, fCalled)

Is it what you're looking for?
Cordialement,

Alain

Re: Function pointers
SystemAdmin - Fri Apr 13 05:05:55 EDT 2012

You are missing the body of your nested function

struct Toto {}
 
void titi(Toto toto, int b){
    void fptr(Toto toto, int b) {
        };
}
 
void tutu(Toto toto, int b){
        titi(toto,b)
}

Adam

Re: Function pointers
SystemAdmin - Fri Apr 13 10:28:57 EDT 2012

struct Toto {}
 
void titi(Toto toto, int b){
    void fptr(Toto toto, int b) {
        };
}
 
void tutu(Toto toto, int b){
        titi(toto,b)
}

No this is not what I was looking for. If you
 

void titi(Toto toto, int b){
    void fptr(Toto toto, int b) {
        };
 
 
}

Re: Function pointers
SystemAdmin - Fri Apr 13 10:35:59 EDT 2012

void titi(Toto toto, int b){
    void fptr(Toto toto, int b) {
        };
 
 
}

Sorry, for some reason my previous message was posted before I could complete it.
No this is not what I was looking for, because fptr cannot be modified with you suggestion. If I do this:
 

void tutu(int a, int b){
  
   print "Hello"
 
}
 
 
void doit(){
    void fptr(int a, int b) {
        };
 
      fptr = tutu
 
        fptr(0, 0);
 
} 
 
doit

Then I get the error:

-E- DXL: <Line:13> Utilisation incorrecte de l'identificateur (fptr)
-I- DXL: Terminé. Erreurs signalées : 1. Avertissements signalés : 0.

But I think that I can find some solution using some other of the answers.

Vincent.

Re: Function pointers
llandale - Fri Apr 13 10:43:05 EDT 2012

struct Toto {}
 
void titi(Toto toto, int b){
    void fptr(Toto toto, int b) {
        };
}
 
void tutu(Toto toto, int b){
        titi(toto,b)
}

Nested functions are practically worthless in DXL since they may not access variables declared in the parent function. This makes them somewhat worthless.

struct Toto {}
 
int y = 5
void titi(Toto toto, int b){
    int x = 1
 
        void fptr(Toto toto, int b) {
                print ">>fptr; x = " x "\n"
                print ">>fptr; b/y = " b "\t" y "\n"
        };
        fptr(toto, b)
}
 
void tutu(Toto toto, int b){
        titi(toto,b)
}
 
Toto tt = null
tutu(tt, 6)

You get "non local variable access (x) error. If you comment out the "print x" command, we see that the nested function can indeed access globabl variables.

Re: Function pointers
SystemAdmin - Fri Apr 13 11:02:24 EDT 2012

void tutu(int a, int b){
  
   print "Hello"
 
}
 
 
void doit(){
    void fptr(int a, int b) {
        };
 
      fptr = tutu
 
        fptr(0, 0);
 
} 
 
doit

-E- DXL: <Line:13> Utilisation incorrecte de l'identificateur (fptr)
-I- DXL: Terminé. Erreurs signalées : 1. Avertissements signalés : 0.

Not sure I understand what you want...

Maybe this??

void tutu(int a, int b)
{
    print("Hello, a=" a ", b=" b "\n")
}
 
 
void doit(void aFunction(int, int))
{
        aFunction(1, 2);
} 
 
doit(tutu)

Adam

Re: Function pointers
SystemAdmin - Fri Apr 13 11:11:43 EDT 2012

// Function Fun
 
/*
  Function Fun
*/
 
 
int* PtrOps_intStarAddressOf(_m &v) {
    int *val = &(addr_ (int (addr_ (v))));
    return (val);
}
 
int PtrOps_addressOfVar(_m& anyVar) {
    int temp = (int addr_ PtrOps_intStarAddressOf(anyVar));
    return temp;
}
 
int PtrOps_internalIntContentOfAddress(int& refToInt) {
    int content = refToInt;
    return content;
}
 
int PtrOps_intContentOfAddress(int address) {
    return (PtrOps_internalIntContentOfAddress(addr_ address));
}
 
 
int PtrOps_addressOfVoidFunctionWithNoParameterHelper(int dummyParameterOne, void function()) {
    int addressOfParameterOne;
    int contentOfParameterOne;
 
    int addressOfParameterTwo;
    int contentOfParameterTwo;
 
    addressOfParameterOne = PtrOps_addressOfVar(dummyParameterOne);
    contentOfParameterOne = PtrOps_intContentOfAddress(addressOfParameterOne);
 
    //--------------------------------------------------------------------------
    // DOORS blows up if you get the address of "void function(void)" function
    // directly.  Alternate approach:
    // 1) Pass in a dummy int parameter prior to the function parameter.
    // 2) Figure out the address of the dummy parameter.
    // 3) We know the temperamental function parameter content is 4 bytes ahead
    //    of the dummy address.
    // 4) Look four bytes ahead and extract an int that lies there.
    // 5) Done
    //--------------------------------------------------------------------------
 
    addressOfParameterTwo = addressOfParameterOne + 4;
    contentOfParameterTwo = PtrOps_intContentOfAddress(addressOfParameterTwo);
 
    return contentOfParameterTwo;
}
 
int PtrOps_addressOfVoidFunctionWithNoParameter(void function()) {
    int dummyParameterOne = 1111;
    return PtrOps_addressOfVoidFunctionWithNoParameterHelper(dummyParameterOne, function);
}
 
int PtrOps_addressOfVoidFunctionWithOneNonRefParameter(void function(_m)) {
    return (int (addr_ function));
}
 
void callNoParameterVoidFunction(void function()) {
    function();
}
 
void callOneParameterVoidFunction(void function(_m)) {
    function("one");
}
 
void oneParameter(string msg) {
    print ">>> Hello from void function with " msg " parameter! <<<\n";
}
 
void noParameter() {
    print ">>> Hello from void function with no parameter! <<<\n";
}
 
void addressOfFunctionDemo() {
    print("I'm calling a one parameter void function directly\n");
    oneParameter("one");
    print("I'm calling a no parameter void function directly\n");
    noParameter();
 
    print("\n");
 
    print("I'm calling a one parameter void function by passing function by typed-function signature\n");
    callOneParameterVoidFunction( oneParameter );
    print("I'm calling a no parameter void function by passing function by typed-function signature\n");
    callNoParameterVoidFunction( noParameter );
 
    print("\n");
 
    int addressOfVoidFunctionWithOneNonRefParameter = PtrOps_addressOfVoidFunctionWithOneNonRefParameter( oneParameter );
    int addressOfVoidFunctionWithNoParameter = PtrOps_addressOfVoidFunctionWithNoParameter( noParameter );
 
    print("The address of a one parameter void function is (in decimal) " (addressOfVoidFunctionWithOneNonRefParameter) "\n");
    print("The address of a no parameter void function is (in decimal) " (addressOfVoidFunctionWithNoParameter) "\n");
 
    print("\n");
 
    print("I'm calling a one parameter void function by hacking-in the address\n");
    callOneParameterVoidFunction( addr_ addressOfVoidFunctionWithOneNonRefParameter );
 
    print("I'm calling a no parameter void function by hacking-in the address\n");
    callNoParameterVoidFunction( addr_ addressOfVoidFunctionWithNoParameter );
}
 
addressOfFunctionDemo();

Hello,

This is very strange, because what you propose almost work, but I get some access violation error, here is my sample code:
 

struct Toto {}
 
int handlerAddress(void handler(Toto toto, int b)){
    return (addr_ handler) int
}
 
void callHandler(void handler(Toto toto, int b), Toto toto, int b){
        handler(toto, b)
}
 
Array handlerList = create(2,1);
 
void handler0(Toto toto, int b){
        print "\n---------------------------\nThis is handler0\n---------------------------"
}
put(handlerList, handlerAddress(handler0), 0, 0)
 
void handler1(Toto toto, int b){
        print "\n---------------------------\nThis is handler1\n---------------------------"
}
 
put(handlerList, handlerAddress(handler1), 1, 0)
 
 
void noAccessViolation(Toto toto, int b){
        int fptr = handlerAddress(handler0)
        callHandler( addr_ fptr, toto, b)
 
        fptr = handlerAddress(handler1)
        callHandler( addr_ fptr, toto, b)
}
 
 
void accessViolation(Toto toto, int b){
        int fptr = get(handlerList, 0, 0);
        callHandler( addr_ fptr, toto, b)
 
        fptr = get(handlerList, 1, 0);
        callHandler( addr_ fptr, toto, b)
 
}
 
Toto createToto(){
        Array this = create(10,1)
        return (addr_ this) Toto
}
 
void deleteToto(Toto toto){
        Array this = (addr_ toto) Array
        delete  this
}
 
 
Toto dummy = createToto
 
noAccessViolation(dummy, 0)
accessViolation(dummy, 0)
 
deleteToto dummy
delete handlerList

The call to noAccessViolation works fine, but the call to accessViolation breaks with an access violation error between the call to handler0 and the call to handler1. Here is what I get:

-W- DXL: <Line:4> Le paramètre de fonction a nommé le paramètre (119348960)
-W- DXL: <Line:4> Le paramètre de fonction a nommé le paramètre (83520656)
-W- DXL: <Line:8> Le paramètre de fonction a nommé le paramètre (119348960)
-W- DXL: <Line:8> Le paramètre de fonction a nommé le paramètre (83520656)
-I- DXL: Terminé. Erreurs signalées : 0. Avertissements signalés : 4.
 
---------------------------
This is handler0
---------------------------
---------------------------
This is handler1
---------------------------
---------------------------
This is handler0
----------------------------R-E- DXL: <Line:39> Une erreur inattendue s'est produite : doors.exe caused an EXCEPTION_ACCESS_VIOLATION in module doors.exe at 001B:009050BD
 
Traçage :
    <Line:58> 
-R-F- DXL: <Line:39> Erreur interne, soumettez un rapport de bogue
Traçage :
        <Line:58> 
-I- DXL: Exécution arrêtée

Re: Function pointers
SystemAdmin - Fri Apr 13 13:55:31 EDT 2012

struct Toto {}
 
int handlerAddress(void handler(Toto toto, int b)){
    return (addr_ handler) int
}
 
void callHandler(void handler(Toto toto, int b), Toto toto, int b){
        handler(toto, b)
}
 
Array handlerList = create(2,1);
 
void handler0(Toto toto, int b){
        print "\n---------------------------\nThis is handler0\n---------------------------"
}
put(handlerList, handlerAddress(handler0), 0, 0)
 
void handler1(Toto toto, int b){
        print "\n---------------------------\nThis is handler1\n---------------------------"
}
 
put(handlerList, handlerAddress(handler1), 1, 0)
 
 
void noAccessViolation(Toto toto, int b){
        int fptr = handlerAddress(handler0)
        callHandler( addr_ fptr, toto, b)
 
        fptr = handlerAddress(handler1)
        callHandler( addr_ fptr, toto, b)
}
 
 
void accessViolation(Toto toto, int b){
        int fptr = get(handlerList, 0, 0);
        callHandler( addr_ fptr, toto, b)
 
        fptr = get(handlerList, 1, 0);
        callHandler( addr_ fptr, toto, b)
 
}
 
Toto createToto(){
        Array this = create(10,1)
        return (addr_ this) Toto
}
 
void deleteToto(Toto toto){
        Array this = (addr_ toto) Array
        delete  this
}
 
 
Toto dummy = createToto
 
noAccessViolation(dummy, 0)
accessViolation(dummy, 0)
 
deleteToto dummy
delete handlerList

-W- DXL: <Line:4> Le paramètre de fonction a nommé le paramètre (119348960)
-W- DXL: <Line:4> Le paramètre de fonction a nommé le paramètre (83520656)
-W- DXL: <Line:8> Le paramètre de fonction a nommé le paramètre (119348960)
-W- DXL: <Line:8> Le paramètre de fonction a nommé le paramètre (83520656)
-I- DXL: Terminé. Erreurs signalées : 0. Avertissements signalés : 4.
 
---------------------------
This is handler0
---------------------------
---------------------------
This is handler1
---------------------------
---------------------------
This is handler0
----------------------------R-E- DXL: <Line:39> Une erreur inattendue s'est produite : doors.exe caused an EXCEPTION_ACCESS_VIOLATION in module doors.exe at 001B:009050BD
 
Traçage :
    <Line:58> 
-R-F- DXL: <Line:39> Erreur interne, soumettez un rapport de bogue
Traçage :
        <Line:58> 
-I- DXL: Exécution arrêtée

I found two problems:
 

• In parameter lists where the parameter is a function and the function has arguments, you just put in the types of the arguments.
• Unless you are feeling extremely lucky, ALWAYS cast when extracting data from one of DXL's flexible objects (e.g., Array, Skip, etc.)

Here is a repaired version of your code:

// Desmond Toto
 
/*
  Desmond Toto
*/
 
 
struct Toto {}
 
// Global ...
Array handlerList;
Toto dummy;
// ... end global
 
void handler0(Toto toto, int b){
    print "\n---------------------------\nThis is handler0\n---------------------------\n"
}
 
void handler1(Toto toto, int b){
    print "\n---------------------------\nThis is handler1\n---------------------------\n"
}
 
 
int handlerAddress(void handler(Toto, int)){
    return (addr_ handler) int
}
 
void callHandler(void handler(Toto, int), Toto toto, int b){
    handler(toto, b)
}
 
void noAccessViolation(Toto toto, int b){
    int fptr = handlerAddress(handler0)
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
 
    fptr = handlerAddress(handler1)
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
}
 
void accessViolation(Toto toto, int b){
    int fptr = (int get(handlerList, 0, 0));
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
    //--------------------------------------------------------------------------
    // If you remove the (int) cast below you'll be in trouble
    // DXL will let you shot youself in the foot
    // ALWAYS cast when extracting data from Array, Skip, etc. to be safe
    //--------------------------------------------------------------------------
    fptr = (int get(handlerList, 1, 0));
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
}
 
Toto createToto(){
    return (Toto addr_ (Array create(10,1)) )
}
 
void deleteToto(Toto toto){
    Array this = (addr_ toto) Array
    delete  this
}
 
void showArray(Array a) {
    print("a[0][0] = " (int get(a, 0, 0)) "\n");
    print("a[0][1] = " (int get(a, 1, 0)) "\n");
    print("handler0 = " (int addr_ handler0) "\n");
    print("handler1 = " (int addr_ handler1) "\n");
}
 
 
void main() {
    handlerList = create(2,1);
    put(handlerList, handlerAddress(handler0), 0, 0)
    put(handlerList, handlerAddress(handler1), 1, 0)
    showArray(handlerList);
    dummy = createToto
    noAccessViolation(dummy, 0)
    accessViolation(dummy, 0)
    deleteToto dummy
    delete handlerList
}
 
main();

OUTPUT:
a[0][0] = 153276328
a[0][1] = 153276352
handler0 = 153276328
handler1 = 153276352
fptr = 153276328

This is handler0

fptr = 153276352

This is handler1

fptr = 153276328

This is handler0

fptr = 153276352

This is handler1

Re: Function pointers
llandale - Fri Apr 13 15:52:30 EDT 2012

// Desmond Toto
 
/*
  Desmond Toto
*/
 
 
struct Toto {}
 
// Global ...
Array handlerList;
Toto dummy;
// ... end global
 
void handler0(Toto toto, int b){
    print "\n---------------------------\nThis is handler0\n---------------------------\n"
}
 
void handler1(Toto toto, int b){
    print "\n---------------------------\nThis is handler1\n---------------------------\n"
}
 
 
int handlerAddress(void handler(Toto, int)){
    return (addr_ handler) int
}
 
void callHandler(void handler(Toto, int), Toto toto, int b){
    handler(toto, b)
}
 
void noAccessViolation(Toto toto, int b){
    int fptr = handlerAddress(handler0)
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
 
    fptr = handlerAddress(handler1)
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
}
 
void accessViolation(Toto toto, int b){
    int fptr = (int get(handlerList, 0, 0));
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
    //--------------------------------------------------------------------------
    // If you remove the (int) cast below you'll be in trouble
    // DXL will let you shot youself in the foot
    // ALWAYS cast when extracting data from Array, Skip, etc. to be safe
    //--------------------------------------------------------------------------
    fptr = (int get(handlerList, 1, 0));
    print("fptr = " (fptr) "\n");
    callHandler( addr_ fptr, toto, b)
}
 
Toto createToto(){
    return (Toto addr_ (Array create(10,1)) )
}
 
void deleteToto(Toto toto){
    Array this = (addr_ toto) Array
    delete  this
}
 
void showArray(Array a) {
    print("a[0][0] = " (int get(a, 0, 0)) "\n");
    print("a[0][1] = " (int get(a, 1, 0)) "\n");
    print("handler0 = " (int addr_ handler0) "\n");
    print("handler1 = " (int addr_ handler1) "\n");
}
 
 
void main() {
    handlerList = create(2,1);
    put(handlerList, handlerAddress(handler0), 0, 0)
    put(handlerList, handlerAddress(handler1), 1, 0)
    showArray(handlerList);
    dummy = createToto
    noAccessViolation(dummy, 0)
    accessViolation(dummy, 0)
    deleteToto dummy
    delete handlerList
}
 
main();

Re: Function pointers
SystemAdmin - Mon Apr 16 03:22:03 EDT 2012

Re: Function pointers
Mathias Mamsch - Mon Apr 16 05:37:12 EDT 2012

void tutu(int a, int b){
  
   print "Hello"
 
}
 
 
void doit(){
    void fptr(int a, int b) {
        };
 
      fptr = tutu
 
        fptr(0, 0);
 
} 
 
doit

-E- DXL: <Line:13> Utilisation incorrecte de l'identificateur (fptr)
-I- DXL: Terminé. Erreurs signalées : 1. Avertissements signalés : 0.

Re: Function pointers
SystemAdmin - Mon Apr 16 08:46:57 EDT 2012

Re: Function pointers
SystemAdmin - Mon Apr 16 15:56:10 EDT 2012

Re: Function pointers
SystemAdmin - Tue Apr 17 03:26:46 EDT 2012

Dear Fu Lin,

DXL supports overloading, but you don't have natively the notion of objects, nor virtual methods. What I mean is that if I have some class
 

struct Toto {}

which serves the purpose of being an interface, and I have one method:

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

And I have two derived classes

struct Titi {} // implements Toto

and

struct Tutu {} // implements Toto

with corresponding interface implementation of mymethod:

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

What I mean by that there is no native vitual method, is that I need some explicit code inside ``void mymethod(Toto toto)'' to call either ``void mymethod(Titi titi)'' or ``void mymethod(Tutu tutu)'' when ``void mymethod(Toto toto)'' is called. Anyway DXL does not allow to declare that Titi and Tutu are derived from Toto, there is no keywords to declare that, once again everything relies on some explicit coding.

Concerning your statement "without making an un-natural programming model" I am not sure to understand what you mean. What I am doing is "un-native" because DXL does not support it natively. It is just like if you made objects and classes with Assembler or with C, you need to implement by hand all the derivation and indirection machinery, and some sort of symbol decoration --- which DXL has natively ---, without the help of the compiler. However, it is not "un-natural", because it just follows the same concepts and techniques that C++ and Java support natively.

Vincent.

PS-1: BTW, is it correct that "Fu Lin" is your forename and "Yiu" your surname?
PS-2: Please ignore the sequel: =test 1= /test 2/

Re: Function pointers
SystemAdmin - Tue Apr 17 03:28:17 EDT 2012

Dear Fu Lin,

DXL supports overloading, but you don't have natively the notion of objects, nor virtual methods. What I mean is that if I have some class
 

struct Toto {}

which serves the purpose of being an interface, and I have one method:

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

And I have two derived classes

struct Titi {} // implements Toto

and

struct Tutu {} // implements Toto

with corresponding interface implementation of mymethod:

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

What I mean by that there is no native vitual method, is that I need some explicit code inside ``void mymethod(Toto toto)'' to call either ``void mymethod(Titi titi)'' or ``void mymethod(Tutu tutu)'' when ``void mymethod(Toto toto)'' is called. Anyway DXL does not allow to declare that Titi and Tutu are derived from Toto, there is no keywords to declare that, once again everything relies on some explicit coding.

Concerning your statement "without making an un-natural programming model" I am not sure to understand what you mean. What I am doing is "un-native" because DXL does not support it natively. It is just like if you made objects and classes with Assembler or with C, you need to implement by hand all the derivation and indirection machinery, and some sort of symbol decoration --- which DXL has natively ---, without the help of the compiler. However, it is not "un-natural", because it just follows the same concepts and techniques that C++ and Java support natively.

Vincent.

PS-1: BTW, is it correct that "Fu Lin" is your forename and "Yiu" your surname?
PS-2: Please ignore the sequel: =test 1= /test 2/

Re: Function pointers
SystemAdmin - Tue Apr 17 03:29:11 EDT 2012

Dear Fu Lin,

DXL supports overloading, but you don't have natively the notion of objects, nor virtual methods. What I mean is that if I have some class
 

struct Toto {}

which serves the purpose of being an interface, and I have one method:

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

And I have two derived classes

struct Titi {} // implements Toto

and

struct Tutu {} // implements Toto

with corresponding interface implementation of mymethod:

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

What I mean by that there is no native vitual method, is that I need some explicit code inside ``void mymethod(Toto toto)'' to call either ``void mymethod(Titi titi)'' or ``void mymethod(Tutu tutu)'' when ``void mymethod(Toto toto)'' is called. Anyway DXL does not allow to declare that Titi and Tutu are derived from Toto, there is no keywords to declare that, once again everything relies on some explicit coding.

Concerning your statement "without making an un-natural programming model" I am not sure to understand what you mean. What I am doing is "un-native" because DXL does not support it natively. It is just like if you made objects and classes with Assembler or with C, you need to implement by hand all the derivation and indirection machinery, and some sort of symbol decoration --- which DXL has natively ---, without the help of the compiler. However, it is not "un-natural", because it just follows the same concepts and techniques that C++ and Java support natively.

Vincent.

PS-1: BTW, is it correct that "Fu Lin" is your forename and "Yiu" your surname?
PS-2: Please ignore the sequel: =test 1= /test 2/

Re: Function pointers
SystemAdmin - Tue Apr 17 03:39:24 EDT 2012

Dear Fu Lin,

DXL supports overloading, but you don't have natively the notion of objects, nor virtual methods. What I mean is that if I have some class
 

struct Toto {}

which serves the purpose of being an interface, and I have one method:

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

And I have two derived classes

struct Titi {} // implements Toto

and

struct Tutu {} // implements Toto

with corresponding interface implementation of mymethod:

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

What I mean by that there is no native vitual method, is that I need some explicit code inside ``void mymethod(Toto toto)'' to call either ``void mymethod(Titi titi)'' or ``void mymethod(Tutu tutu)'' when ``void mymethod(Toto toto)'' is called. Anyway DXL does not allow to declare that Titi and Tutu are derived from Toto, there is no keywords to declare that, once again everything relies on some explicit coding.

Concerning your statement "without making an un-natural programming model" I am not sure to understand what you mean. What I am doing is "un-native" because DXL does not support it natively. It is just like if you made objects and classes with Assembler or with C, you need to implement by hand all the derivation and indirection machinery, and some sort of symbol decoration --- which DXL has natively ---, without the help of the compiler. However, it is not "un-natural", because it just follows the same concepts and techniques that C++ and Java support natively.

Vincent.

PS-1: BTW, is it correct that "Fu Lin" is your forename and "Yiu" your surname?
PS-2: Please ignore the sequel: =test 1= /test 2/

Re: Function pointers
Mathias Mamsch - Tue Apr 17 07:04:37 EDT 2012

struct Toto {}

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

struct Titi {} // implements Toto

struct Tutu {} // implements Toto

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

Ok, Maybe you are moving into being more object oriented? If you wanted to have "virtual functions" and inheritance from a Base class you would do something like this in DXL:
 

struct Base {}
 
// constructor & destructor for Base
Base createBase_ () { DxlObject dx = new; Base x = (addr_ dx) Base; return x}
DxlObject DxlObjectOf (Base x) { return ((addr_ x) DxlObject) }
void VirtualFunction_ (Base &x) { DxlObject dx = DxlObjectOf x; delete dx; x = null; }
 
// virtual function VirtualFunction property:
void set_VirtualFunction (Base var, void func (Base &)) { (DxlObjectOf var)->"adVirtualFunction" = ((addr_ func) int) }
void call_VirtualFunction (void func (Base &), Base &this) { func( this ) }
 
// virtual function VirtualFunction proxy:
void VirtualFunction (Base this) { 
    if (null this) { return false }
    int ad = ((DxlObjectOf this)->"adVirtualFunction") int 
    if (ad != 0) call_VirtualFunction (addr_ ad,  this)
    
    VirtualFunction_ this
}
 
struct Derived1 {}
Base super (Derived1 this) { return ((addr_ this) Base) }
 
 
struct Derived2 {}
Base super (Derived2 this) { return ((addr_ this) Base) }
 
// virtual function VirtualFunction proxy:
void Derived1_VirtualFunction (Base &this) {
    Base deref = this 
    Derived1 mst = addr_ deref
    print "Virtual Function of Derived1\n" 
}
 
 
Derived1 createDerived1 () {
    Base st = createBase_()
    Derived1 stMod = addr_ st 
    set_VirtualFunction (st, Derived1_VirtualFunction)
    return ((addr_ st) Derived1)
}
 
// virtual function VirtualFunction proxy:
void Derived2_VirtualFunction (Base &this) {
    Base deref = this 
    Derived2 mst = addr_ deref
    print "Virtual Function of Derived2\n" 
}
 
Derived2 createDerived2 () {
    Base st = createBase_()
    Derived1 stMod = addr_ st 
    set_VirtualFunction (st, Derived2_VirtualFunction)
    return ((addr_ st) Derived2)
}
 
// ---------------------snip end library code ----------------
 
 
Derived1 d1 = createDerived1()
VirtualFunction super d1   // call a base class function 
 
Derived2 d2 = createDerived2()
VirtualFunction super d2   // call a base class function

This way you can have you base class with your virtual functions and your sweet functionality in your base class while the special implementation of the derived classes is completly hidden from the base class function. I used this method to implement a 'Storage' class with an interface to read a file, write a file, list files, create a directory, delete a directory, etc. Then I created derived classes for:

• The File System
• The DOORS Config Area
• A Memory Storage
• A DOORS Module (Using Hierarchy as Filesystem and an attribute as file contents)

Now I can write a File Explorer working on the Storage Base Class, and it will work for showing the contents of all the above. Or I could have a copy function to copy files from one Storage to Another, which will allow me to copy files from Config Area to File System, From File System to Memory, etc. That approach works really well.

Maybe that informations helps, regards, Mathias

Mathias Mamsch, IT-QBase GmbH, Consultant for Requirement Engineering and D00RS

Re: Function pointers
SystemAdmin - Tue Apr 17 17:31:54 EDT 2012

struct Toto {}

void mymethod(Toto toto) // virtual method
{ 
   /* ...  here I do the call to the derived class method implementing void mymethod(Toto toto), I do that by some explicit code because DXL 
       does not support natively virtual method ... */
}

struct Titi {} // implements Toto

struct Tutu {} // implements Toto

void mymethod(Titi titi){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Titi derivation ... */
}
 
void mymethod(Tutu tutu){
   /* ...  here I do the the actual implementation void mymethod(Toto toto) according to Tutu derivation ... */
}

Interfaces come in handy when you want to farm work out to a third party (or a co-worker) and you don't care about the implementation but want a standard interface.

In Java you can create (or reference) an interface and say (for example) your software product must implement Iterator for some object type.

See:
http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html

http://en.wikipedia.org/wiki/Iterator#Java

As an integrator of works from third parties and developers, the interface is handy because if the third parties said they would implement an interface but there is no body to correspond, it won't compile. In DXL one could #include the below but you would only know a member was not implemented if had code that called it.

Mapping to the DXL, I'd like to say "You must implement this:"
 

// Suppose this is in "ThirdPartyIterator.inc" which is #included in the source module
 
struct ThirdPartyObjectType {};
 
// Returns true if the iteration has more elements.
boolean hasNext(ThirdPartyObjectType);
 
// Returns the next element in the iteration.
ThirdPartyObjectType next(ThirdPartyObjectType);
 
// Removes from the underlying collection the last element returned by this iterator // (optional operation).
void remove(ThirdPartyObjectType);

Other than calling them to see if they blow up, how could you get the DXL compiler tell you if hasNext() and next() were implemented per the interface contract?

Re: Function pointers
Mathias Mamsch - Wed Apr 18 09:09:37 EDT 2012

// Suppose this is in "ThirdPartyIterator.inc" which is #included in the source module
 
struct ThirdPartyObjectType {};
 
// Returns true if the iteration has more elements.
boolean hasNext(ThirdPartyObjectType);
 
// Returns the next element in the iteration.
ThirdPartyObjectType next(ThirdPartyObjectType);
 
// Removes from the underlying collection the last element returned by this iterator // (optional operation).
void remove(ThirdPartyObjectType);

Re: Function pointers
SystemAdmin - Wed Apr 18 14:07:47 EDT 2012

Re: Function pointers
llandale - Wed Apr 18 14:55:10 EDT 2012

Not quite. Yes DXL gives no error when there is no resolved body, but it does give an error when code HAS a reference to it; the error is at interpret time not execution time.

void A(string)    // unresolved
void B(string)    // unresolved
print "Hello\n"   // never executes
if (false) A("SS") // interpret error here

Perhaps I'm missing something, but I see no particular problem if there is a forward declare that is not resolved and is also not used. That's like a function with an infinite loop that is never called, who cares? You would get the error if you did try to use it.

-Louie

Re: Function pointers
SystemAdmin - Wed Apr 18 15:55:19 EDT 2012

void A(string)    // unresolved
void B(string)    // unresolved
print "Hello\n"   // never executes
if (false) A("SS") // interpret error here

Re: Function pointers
llandale - Wed Apr 18 17:59:21 EDT 2012

So in that one particular case which will come up a max twice in your lifetime, you must write an additional testing routine, turning your forward declare include into an actual call include.
If this is your forward declare contract:...

void a(string)
void b(void)

... Then you need to do this to overcome this "limitation" of DOORS

#include forward declare contract
#include stuff from the coder
halt
a("")
b()

Not trying to be abrasive, but if you think this is pretty serious you need to stop using DXL now because you are going to run into all sorts of annoying "features" that exist in other languages. Not to mention down right bugs:

string A(string s)
{  return "<<in 'A', s = [" s "]>>"
}
print "Line1 " (A("Hello")) " but now this\n"
print "Line2 "  A("Hello")  " but now this\n"

Both print statements are functionally identical, but you get this:

Line1 <<in 'A', s = [Hello]>> but now this
Line2 <<in 'A', s = [Hello but now this
]>>

the 2nd one, notice that "but now this" is passed into A ignoring the end paren ")". Figuring out how that came about is harder than figuring out why hot dogs come in packs of 10 yet buns in packs of 8.

-Louie

Repeat after me: "Howuuuuuuuuuummmmm, it is what it is"

Re: Function pointers
SystemAdmin - Wed Apr 18 18:51:14 EDT 2012

void a(string)
void b(void)

#include forward declare contract
#include stuff from the coder
halt
a("")
b()

string A(string s)
{  return "<<in 'A', s = [" s "]>>"
}
print "Line1 " (A("Hello")) " but now this\n"
print "Line2 "  A("Hello")  " but now this\n"

Line1 <<in 'A', s = [Hello]>> but now this
Line2 <<in 'A', s = [Hello but now this
]>>